// 这个是求两个数中最小值的函数，调用函数的时候需要传两个参数
function minNum(a, b) {
    var num = a > b ? b : a
    return num
}

// 这个是求两个数中最大值的函数，调用函数的时候需要传两个参数
function maxNum(a, b) {
    var num = a > b ? a : b
    return num
}

// 求任意多数最大值
function max() {
    // 假设第一个参数为最大的值
    var maxNum = arguments[0];
    // 遍历所有的实参
    for (var i = 0; i < arguments.length; i++) {
        // 把假设的最大值与所有实参比较，如果有一个值大于假设的最大值，就把这个值赋值给 maxNum
        if (maxNum < arguments[i]) {
            maxNum = arguments[i]
        }
    }
    return maxNum
}

function min() {
    // 假设第一个参数为最小的值
    var minNum = arguments[0];
    // 遍历所有的实参
    for (var i = 0; i < arguments.length; i++) {
        // 把假设的最小值与所有实参比较，如果有一个值小于假设的最小值，就把这个值赋值给 maxNum
        if (minNum > arguments[i]) {
            minNum = arguments[i]
        }
    }
    return minNum
}

// 任意两个数之间的随机数  调用函数的时候需要传两个数值的参数
function randomNum(n, m) {

    // 判断两个参数的大小
    var max, min;
    max = n > m ? n : m;
    min = n < m ? n : m;
    return parseInt(Math.random() * (max - min + 1) + min);

}

// 随机颜色
function randomColor(){
    var red = randomNum(0,255);
    var green = randomNum(0,255);
    var blue = randomNum(0,255);
    return 'rgb('+red+','+green+','+blue+')';

}

// 时间格式化
function dataStyle(data) {
    var year = data.getFullYear();
    var month = data.getMonth() + 1;
    month = createZero(month)

    var dat = data.getDate();
    dat = createZero(dat)

    var day = data.getDay();
    var h = data.getHours();
    h = createZero(h)

    var m = data.getMinutes();
    m = createZero(m)

    var s = data.getSeconds();
    s = createZero(s)
    var arr = ["星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六"]
    return year + "-" + month + "-" + dat + " " + h + ":" + m + ":" + s + " " + arr[day]
}

// 补零(补字符的零)
function createZero(n){
    if(typeof n === "string"){
        if(n.length < 2){
            return "0" + n
        }
        return n;
    }else{
        if(n<10){
            return "0"+n;
        }
        return n;
    }
}

// 两个事件的时间差
function timeCha(data1,data2,callback){
    var t1 = data1.getTime()
    var t2 = data2.getTime()

    var day = parseInt(Math.abs(t2-t1)/1000/60/60/24);
    var hours =parseInt(( Math.abs(t2-t1)/1000/60/60 )% 24) 
    var min =parseInt(( Math.abs(t2-t1)/1000/60 )% 60) 
    var second =parseInt(( Math.abs(t2-t1)/1000)% 60)
    var obj = {day:day,hour:hours,min:min,second:second}
    return callback(obj)
}

// 封装一个函数 来获取非行内样式
function getStyle(ele, attr) {
    var style;
    if (ele.currentStyle) {
        //  ele.currentStyle 包含 所有css样式的对象
        // obj.attr 获取 obj的 attr的属性
        style = ele.currentStyle[attr];
    } else {
        style = window.getComputedStyle(ele)[attr];
    }
    // 把获取的样式返回
    return style
}

// 监听事件 
/* 
    当执行这个函数
    必须的参数
        ele:事件源 
        type:事件类型（不需要加on）
        callback ：回调函数，用来作为事件处理函数，执行事件需要写的代码都写callback中
*/
function attaEvent(ele, type, callback) {
    if (ele.addEventListener) {
        ele.addEventListener(type, function () {
            callback()
        })
    } else {
        ele.attachEvent('on' + type, function () {
            callback()
        })
    }
}


/* 
    运动函数： 有3个参数
    参数1：dom元素 参加动画元素
    参数2：一个对象，这个元素什么属性参加动画
    参数3：一个回调函数
*/
function move(ele, obj, callback) {

    let timerLen = 0;
    for (let key in obj) {
        timerLen++
        let speed;
        clearInterval(ele[key])
        // 给这个对象添加一个 left 属性，属性值为 一个定时器的空间地址
        ele[key] = setInterval(() => {
            let style;
            // 0-1 *100 == 0-100   0.1*100 = 10
            if (key === 'opacity') {
                style = getStyle(ele, key) * 100;
            } else {
                style = parseInt(getStyle(ele, key));
            }
            // 0 - 4 = -4/5 = -0.8 向上取整 = 0
            speed = (obj[key] - style) / 5;

            // 如果计算出来的 speed 大于0 向上取整，如果小于0就向下取整
            speed = speed > 0 ? Math.ceil(speed) : Math.floor(speed);
            style = style + speed;

            if (key === 'opacity') {
                ele.style[key] = style / 100;
            } else {
                ele.style[key] = style + 'px';
            }

            // 如果先执行回调函数 再给 元素设置 样式，会先把回调函数中的 所有 代码执行完成之后再执行后面代码
            if (style === obj[key]) {
                clearInterval(ele[key]);
                timerLen--;
                if (timerLen === 0) {
                    // 短路运算 如果有callback 就执行callback，没有就不执行
                    callback && callback();
                }
            }
            // style = -3000
            // if (key === 'opacity') {
            //     ele.style[key] = style / 100;
            // } else {
            //     ele.style[key] = style + 'px';
            // }
            // 当时间 为60的时候，30次 1800毫秒 才能把内层的定时器执行完成
            // 外层的定时器 是1300毫秒执行一次，会造成的问题就是 内层的定时器还没有执行完成 外层定时器有重新执行了

            // if (style === obj[key]) {
            //     clearInterval(ele[key]);
            //     timerLen--;
            //     if (timerLen === 0) {
            //         // 短路运算 如果有callback 就执行callback，没有就不执行
            //         callback && callback();
            //     }
            // } else {
            //     if (key === 'opacity') {
            //         ele.style[key] = (style + speed) / 100;
            //     } else {
            //         ele.style[key] = style + speed + 'px';
            //     }
            // }

        }, 30)
    }

}